package com.spring.crm.conf;

/**
 * @author Tianshuo
 * @date 2021/1/14 20:20
 */

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.IOException;


public class CryptUtils {
    private static String Algorithm = "DES";
    private static byte[] DEFAULT_KEY=new byte[] {-53, 122, -42, -88, -110, -123, -60, -74};
    private static String VALUE_ENCODING="UTF-8";


    /**
     * 生成密钥
     *
     * @return byte[] 返回生成的密钥

     *             扔出异常.
     */
    public static byte[] getSecretKey() throws Exception {
        KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);
        SecretKey deskey = keygen.generateKey();
        // if (debug ) System.out.println ("生成密钥:"+byte2hex (deskey.getEncoded
        // ()));
        return deskey.getEncoded();

    }

    /**
     * 将指定的数据根据提供的密钥进行加密
     *
     * @param input
     *            需要加密的数据
     * @param key
     *            密钥
     * @return byte[] 加密后的数据
     * @throws Exception
     */
    public static byte[] encryptData(byte[] input, byte[] key) throws Exception {
        SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm);
        // if (debug )
        // {
        // System.out.println ("加密前的二进串:"+byte2hex (input ));
        // System.out.println ("加密前的字符串:"+new String (input ));
        //
        // }
        Cipher c1 = Cipher.getInstance(Algorithm);
        c1.init(Cipher.ENCRYPT_MODE, deskey);
        byte[] cipherByte = c1.doFinal(input);
        // if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));
        return cipherByte;

    }

    public static byte[] encryptData(byte[] input) throws Exception {
        return encryptData(input, DEFAULT_KEY);
    }

    /**
     * 将给定的已加密的数据通过指定的密钥进行解密
     *
     * @param input
     *            待解密的数据
     * @param key
     *            密钥
     * @return byte[] 解密后的数据
     * @throws Exception
     */
    public static byte[] decryptData(byte[] input, byte[] key) throws Exception {
        SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm);
        // if (debug ) System.out.println ("解密前的信息:"+byte2hex (input ));
        Cipher c1 = Cipher.getInstance(Algorithm);
        c1.init(Cipher.DECRYPT_MODE, deskey);
        byte[] clearByte = c1.doFinal(input);
        // if (debug )
        // {
        // System.out.println ("解密后的二进串:"+byte2hex (clearByte ));
        // System.out.println ("解密后的字符串:"+(new String (clearByte )));
        //
        // }
        return clearByte;

    }

    public static byte[] decryptData(byte[] input) throws Exception {
        return decryptData(input, DEFAULT_KEY);
    }

    /**
     * 字节码转换成16进制字符串
     *
     * @param byte[] b 输入要转换的字节码
     * @return String 返回转换后的16进制字符串
     */
    public static String byte2hex(byte[] bytes) {
        StringBuilder hs = new StringBuilder();
        for(byte b : bytes)
            hs.append(String.format("%1$02X", b));
        return hs.toString();
    }

    public static byte[] hex2byte(String content) {
        int l=content.length()>>1;
        byte[] result=new byte[l];
        for(int i=0;i<l;i++) {
            int j=i<<1;
            String s=content.substring(j, j+2);
            result[i]=Integer.valueOf(s, 16).byteValue();
        }
        return result;
    }

    /**
     * 将字节数组转换为base64编码字符串
     * @param buffer
     * @return
     */
    public static String bytesToBase64(byte[] buffer) {
        //BASE64Encoder en=new BASE64Encoder();
        return Base64.encode(buffer);
//		return encoder.encode(buffer);
    }

    /**
     * 将base64编码的字符串解码为字节数组
     * @param value
     * @return
     * @throws IOException
     */
    public static byte[] base64ToBytes(String value) throws IOException {
        //return Base64.decodeToByteArray(value);
//		System.out.println(decoder.decodeBuffer(value));
//		return decoder.decodeBuffer(value);
        return Base64.decode(value);
    }

    /**
     * 加密给定的字符串
     * @param value
     * @return 加密后的base64字符串
     */
    public static String encryptString(String value) {
        return encryptString(value, DEFAULT_KEY);
    }

    /**
     * 根据给定的密钥加密字符串
     * @param value 待加密的字符串
     * @param key 以BASE64形式存在的密钥
     * @return 加密后的base64字符串
     * @throws IOException
     */
    public static String encryptString(String value, String key) throws IOException {
        return encryptString(value, base64ToBytes(key));
    }

    /**
     * 根据给定的密钥加密字符串
     * @param value 待加密的字符串
     * @param key 字节数组形式的密钥
     * @return 加密后的base64字符串
     */
    public static String encryptString(String value, byte[] key) {
        try {
            byte[] data=value.getBytes(VALUE_ENCODING);
            data=CryptUtils.encryptData(data, key);
            return bytesToBase64(data);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 解密字符串
     * @param value base64形式存在的密文
     * @return 明文
     */
    public static String decryptString(String value) {
        return decryptString(value, DEFAULT_KEY);
    }

    /**
     * 解密字符串
     * @param value base64形式存在的密文
     * @param key base64形式存在的密钥
     * @return 明文
     * @throws IOException
     */
    public static String decryptString(String value, String key) throws IOException {
        String s=decryptString(value, base64ToBytes(key));
        return s;
    }

    /**
     * 解密字符串
     * @param value base64形式存在的密文
     * @param key 字节数据形式存在的密钥
     * @return 明文
     */
    public static String decryptString(String value, byte[] key) {
        try {
            byte[] data=base64ToBytes(value);
            data=CryptUtils.decryptData(data, key);
            return new String(data, VALUE_ENCODING);
        }catch(Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

